home *** CD-ROM | disk | FTP | other *** search
/ The PC-SIG Library 10 / The PC-Sig Library - Shareware for the IBM PC and Compatibles (PC-SIG)(Tenth Edition Disks 1-2804)(1991).iso / PC_SIGCD / 22 / 4 / DISK2247.ZIP / CBASE101.ZIP / BTREE101.ZIP / DGOPS.C < prev    next >
Text File  |  1990-06-20  |  8KB  |  334 lines
  1. /*    Copyright (c) 1989 Citadel    */
  2. /*       All Rights Reserved        */
  3.  
  4. /* #ident    "@(#)dgops.c    1.4 - 90/06/20" */
  5.  
  6. #include <blkio.h>
  7. #include <ctype.h>
  8. #include <errno.h>
  9. #include <stdio.h>
  10. /*#include <string.h>*/
  11.  
  12. /* local headers */
  13. #include "btree_.h"
  14.  
  15. #ifdef AC_HDRS
  16. static void printkey(FILE *fp, const char *buf, size_t n);
  17. #else
  18. static void printkey();
  19. #endif
  20.  
  21. /*man---------------------------------------------------------------------------
  22. NAME
  23.      bt_dgbtp - btree diagnostics for control structure
  24.  
  25. SYNOPSIS
  26.      #include "btree_.h"
  27.  
  28.      void bt_dgbtp(btp, fp)
  29.      btree_t *btp;
  30.      FILE *fp;
  31.  
  32. DESCRIPTION
  33.      The bt_dgbtp function writes the contents of btree control
  34.      structure btp in a printable format to file fp.
  35.  
  36. SEE ALSO
  37.      bt_dgbtree, bt_dgnode, bt_dgtuple.
  38.  
  39. PORTABILITY WARNING
  40.      bt_dgbtp assumes that size_t is unsigned int.
  41.  
  42. ------------------------------------------------------------------------------*/
  43. void bt_dgbtp(btp, fp)
  44. btree_t *btp;
  45. FILE *fp;
  46. {
  47.     fputs("------------------------------------\n", fp);
  48.     fputs("| btree control structure contents |\n", fp);
  49.     fputs("|----------------------------------|\n", fp);
  50.     if (!bt_valid(btp)) {
  51.         fprintf(fp, "|  btp          = %p.\n", btp);
  52.         fputs("|  Invalid btree pointer           |\n", fp);
  53.         fputs("------------------------------------\n", fp);
  54.         return;
  55.     }
  56.     fprintf(fp, "|  hdr.flh      = %lu.\n", btp->bthdr.flh);
  57.     fprintf(fp, "|  hdr.m        = %d.\n", btp->bthdr.m);
  58.     fprintf(fp, "|  hdr.keysize  = %u.\n", btp->bthdr.keysize);
  59.     fprintf(fp, "|  hdr.flags    = %Xh.\n", btp->bthdr.flags);
  60.     fprintf(fp, "|  hdr.root     = %lu.\n", btp->bthdr.root);
  61.     fprintf(fp, "|  hdr.first    = %lu.\n", btp->bthdr.first);
  62.     fprintf(fp, "|  hdr.last     = %lu.\n", btp->bthdr.last);
  63.     fprintf(fp, "|  hdr.keycnt   = %lu.\n", btp->bthdr.keycnt);
  64.     fprintf(fp, "|  hdr.height   = %lu.\n", btp->bthdr.height);
  65.     fprintf(fp, "|  bp           = %p.\n", btp->bp);
  66.     fprintf(fp, "|  flags        = %Xh.\n", btp->flags);
  67.     fprintf(fp, "|  fldc         = %d.\n", btp->fldc);
  68.     fprintf(fp, "|  fldv         = %p.\n", btp->fldv);
  69.     fprintf(fp, "|  cbtpos.node  = %lu.\n", btp->cbtpos.node);
  70.     fprintf(fp, "|  cbtpos.key   = %d.\n", btp->cbtpos.key);
  71.     fprintf(fp, "|  cbtnp        = %p.\n", btp->cbtnp);
  72.     fprintf(fp, "|  sp           = %p.\n", btp->sp);
  73.     fputs("------------------------------------\n", fp);
  74.  
  75.     return;
  76. }
  77.  
  78. /*man---------------------------------------------------------------------------
  79. NAME
  80.      bt_dgbtree - btree diagnostics for tree
  81.  
  82. SYNOPSIS
  83.      #include "btree_.h"
  84.  
  85.      int bt_dgbtree(btp, node, fp)
  86.      btree_t *btp;
  87.      bpos_t node;
  88.      FILE *fp;
  89.  
  90. DESCRIPTION
  91.      The bt_dgbtree command dumps the contents of btree file to the
  92.      text file associated with FILE pointer fp.  The contents of each
  93.      node is written, starting with node node and descending in a
  94.      preorder traversal of the tree.
  95.  
  96. SEE ALSO
  97.      bt_dgbtp, bt_dgnode, bt_dgtuple.
  98.  
  99. EXAMPLE
  100.      The following call will display the contents of an entire tree on
  101.      the screen.
  102.  
  103.           bt_dgbtree(btp, btp->bthdr.root, stdout);
  104.  
  105. ------------------------------------------------------------------------------*/
  106. int bt_dgbtree(btp, node, fp)
  107. btree_t *btp;
  108. bpos_t node;
  109. FILE *fp;
  110. {
  111.     btnode_t *btnp = NULL;
  112.     int i = 0;
  113.  
  114.     /* check for bottom of tree */
  115.     if (node == NIL) {
  116.         errno = 0;
  117.         return 0;
  118.     }
  119.  
  120.     /* read node and display */
  121.     btnp = bt_ndalloc(btp);
  122.     if (btnp == NULL) {
  123.         BTEPRINT;
  124.         return -1;
  125.     }
  126.     if (bt_ndget(btp, node, btnp) == -1) {
  127.         BTEPRINT;
  128.         bt_ndfree(btnp);
  129.         return -1;
  130.     }
  131.     fprintf(fp, "Node block:  %lu.\n", node);
  132.     bt_dgnode(btp, btnp, fp);
  133.     fputc('\n', fp);
  134.  
  135.     /* recurse rest of tree */
  136.     for (i = 0; i < btp->bthdr.m; ++i) {
  137.         if (bt_dgbtree(btp, *bt_kychildp(btnp, i), fp) == -1) {
  138.             return -1;
  139.         }
  140.     }
  141.  
  142.     bt_ndfree(btnp);
  143.     btnp = NULL;
  144.  
  145.     errno = 0;
  146.     return 0;
  147. }
  148.  
  149. /*man---------------------------------------------------------------------------
  150. NAME
  151.      bt_dgnode - btree diagnostics for node
  152.  
  153. SYNOPSIS
  154.      #include "btree_.h"
  155.  
  156.      void bt_dgnode(btp, btnp, fp)
  157.      btree_t *btp;
  158.      btnode_t *btnp;
  159.      FILE *fp;
  160.  
  161. DESCRIPTION
  162.      The bt_dgnode function writes the contents of node btnp of btree
  163.      btp in a printable format to file fp.
  164.  
  165. SEE ALSO
  166.      bt_dgbtp, bt_dgbtree, bt_dgtuple.
  167.  
  168. ------------------------------------------------------------------------------*/
  169. void bt_dgnode(btp, btnp, fp)
  170. btree_t *btp;
  171. btnode_t *btnp;
  172. FILE *fp;
  173. {
  174.     int i = 0;
  175.  
  176.     fputs("--------------------------\n", fp);
  177.     fputs("| btree node contents    |\n", fp);
  178.     fputs("--------------------------\n", fp);
  179.     if (!bt_valid(btp)) {
  180.         fprintf(fp, "|  btp          = %p.\n", btp);
  181.         fputs("|  Invalid btree pointer |\n", fp);
  182.         fputs("--------------------------\n", fp);
  183.         return;
  184.     }
  185.     if (btnp == NULL) {
  186.         fputs("|  btnp         = NULL   |\n", fp);
  187.         fputs("--------------------------\n", fp);
  188.         return;
  189.     }
  190.     if (btnp->lsib == NIL) {
  191.         fprintf(fp, "|  lsib         = NIL\n");
  192.     } else {
  193.         fprintf(fp, "|  lsib         = %lu\n", btnp->lsib);
  194.     }
  195.     if (btnp->rsib == NIL) {
  196.         fprintf(fp, "|  rsib         = NIL\n");
  197.     } else {
  198.         fprintf(fp, "|  rsib         = %lu\n", btnp->rsib);
  199.     }
  200.     fprintf(fp, "|  n            = %d\n", btnp->n);
  201.     fprintf(fp, "|  keyv         = %p\n", btnp->keyv);
  202.     fprintf(fp, "|  childv       = %p\n", btnp->childv);
  203.     if (btnp->keyv == NULL || btnp->childv == NULL) {
  204.         fputs("--------------------------\n", fp);
  205.         return;
  206.     }
  207.     if (*bt_kychildp(btnp, 0) == NIL) {
  208.         fputs("|  child[0] = NIL\n", fp);
  209.     } else {
  210.         fprintf(fp, "|  child[0] = %lu\n", *bt_kychildp(btnp, 0));
  211.     }
  212.     for (i = 1; (i <= btp->bthdr.m); ++i) {
  213.         fprintf(fp, "|  key[%d] = \"", i);
  214.         printkey(fp, bt_kykeyp(btp, btnp, i), btkeysize(btp));
  215.         fputs("\"\n", fp);
  216.         if (*bt_kychildp(btnp, i) == NIL) {
  217.             fprintf(fp, "|  child[%d] = NIL\n", i);
  218.         } else {
  219.             fprintf(fp, "|  child[%d] = %lu\n", i, *bt_kychildp(btnp, i));
  220.         }
  221.     }
  222.     fputs("--------------------------\n", fp);
  223.  
  224.     return;
  225. }
  226.  
  227. /*man---------------------------------------------------------------------------
  228. NAME
  229.      bt_dgtuple - btree diagnostics for tuple
  230.  
  231. SYNOPSIS
  232.      #include "btree_.h"
  233.  
  234.      void bt_dgtuple(btp, bttplp, fp)
  235.      btree_t *btp;
  236.      bttpl_t *bttplp;
  237.      FILE *fp;
  238.  
  239. DESCRIPTION
  240.      The bt_dgtuple function writes the contents of tuple bttplp of
  241.      btree btp in a printable format to file fp.
  242.  
  243. SEE ALSO
  244.      bt_dgbtp, bt_dgbtree, bt_dgnode.
  245.  
  246. ------------------------------------------------------------------------------*/
  247. void bt_dgtuple(btp, bttplp, fp)
  248. btree_t *btp;
  249. bttpl_t *bttplp;
  250. FILE *fp;
  251. {
  252.     fputs("--------------------------\n", fp);
  253.     fputs("|btree bttpl contents   |\n", fp);
  254.     fputs("|------------------------|\n", fp);
  255.     if (!bt_valid(btp)) {
  256.         fprintf(fp, "|  btp          = %p.\n", btp);
  257.         fputs("|  Invalid btree pointer |\n", fp);
  258.         fputs("--------------------------\n", fp);
  259.         return;
  260.     }
  261.     if (bttplp == NULL) {
  262.         fputs("|  bttplp       = NULL   |\n", fp);
  263.         fputs("--------------------------\n", fp);
  264.         return;
  265.     }
  266.     if (bttplp->keyp == NULL) {
  267.         fputs("|  bttplp->keyp = NULL   |\n", fp);
  268.         fputs("--------------------------\n", fp);
  269.         return;
  270.     }
  271.     fputs("|  key          = \"", fp);
  272.     printkey(fp, bttplp->keyp, btkeysize(btp));
  273.     fputs("\"\n", fp);
  274.     if (bttplp->child == NIL) {
  275.         fputs("|  child        = NIL    |\n", fp);
  276.     } else {
  277.         fprintf(fp, "|  child        = %lu.\n", bttplp->child);
  278.     }
  279.     fputs("--------------------------\n", fp);
  280.  
  281.     return;
  282. }
  283.  
  284. static void printkey(fp, buf, n)
  285. FILE *fp;
  286. const char *buf;
  287. size_t n;
  288. {
  289.     int i = 0;
  290.     int c = 0;
  291.  
  292.     for (i = 0; i < n; ++i) {
  293.         c = buf[i];
  294.         switch (c) {
  295.         case '\a':    /* BEL */
  296.             fprintf(fp, "\\a");
  297.             break;
  298.         case '\b':    /* BS */
  299.             fprintf(fp, "\\b");
  300.             break;
  301.         case '\f':    /* FF */
  302.             fprintf(fp, "\\f");
  303.             break;
  304.         case '\n':    /* NL */
  305.             fprintf(fp, "\\n");
  306.             break;
  307.         case '\r':    /* CR */
  308.             fprintf(fp, "\\r");
  309.             break;
  310.         case '\t':    /* HT */
  311.             fprintf(fp, "\\t");
  312.             break;
  313.         case '\v':    /* VT */
  314.             fprintf(fp, "\\v");
  315.             break;
  316.         case '\\':
  317.             fprintf(fp, "\\\\");
  318.             break;
  319.         case '\"':
  320.             fprintf(fp, "\\\"");
  321.             break;
  322.         default:
  323.             if (isprint(c)) {
  324.                 fputc(c, fp);
  325.             } else {
  326.                 fprintf(fp, "\\%.3o", c);
  327.             }
  328.             break;
  329.         }
  330.     }
  331.  
  332.     return;
  333. }
  334.